
/******************/
/* TP3 - GRUPO 13 */
/******************/
/* Andre Bonna    */
/* Artur Gontijo  */
/* Ivo Trivella   */
/******************/


#include "func.h"

 
/* ------------------------------------------------------------------------------- */

/* Imprime o menu de funcionalidades do programa e direciona a execucao para a opcao escolhida */
void menup(FILE **basept, FILE **arq, reg *dados, tipoindice *pk, tipoindice *titulo, tipoindice *tipo, tipoindice *autor, tipoindice *ano, int *alocados) {
  int cont=0;
  char opt, resp, target[MAX_TIT], nomearq[NOMEARQTAM];
  tipocelsk *f;
  
  printf("\n\n ***********  M E N U    P R I N C I P A L  *********** \n");
  printf("|                                                      |\n");
  printf("|   1 - [I]NSERIR uma nova obra no banco de dados      |\n");
  printf("|   2 - [R]EMOVER uma nova obra do banco de dados      |\n");
  printf("|   3 - [B]USCAR uma obra do banco de dados            |\n");
  printf("|   4 - [L]ISTAR todas as obras do banco de dados      |\n");
  printf("|   5 - [S]AIR do programa                             |\n");
  printf("|                                                      |\n");
  printf(" ****************************************************** \n");
  printf("\n ==> Digite o numero ou a letra da opcao desejada: ");
 
  opt = getchar();

  /* Age de acordo com a opcao do usuario */
  switch(opt) {
  case '1':
  case 'i':
  case 'I':
    /* Insere */
    __fpurge(stdin);
    add(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);
    break;

  case '2':
  case 'r':
  case 'R':
    /* Remove */
    system("clear");    
    getchar();
    printf("\n ==> Remover [Titulo]: ");
    scanf("%[^\n]", target);
    
    for(cont=strlen(target); cont < MAX_TIT; cont++){
      target[cont] = ' ';
    }
    target[cont] = '\0';
    
    f = buscat(pk, target);

    if (f != NULL){
      printf("\n ***** Titulo Encontrado!!! ***** \n ==> Posicao: [%04d]\n\n", f->pos);
      getchar();
      strcpy(target, f->sk); /* Armazena o Titulo que será removido para a impressao na tela */
      printf("     Deseja remover esse Titulo? [s/n]: ");
      scanf("%c", &resp );
      getchar();
      if ( resp == 's'){
	remocao(basept, arq, dados, pk, titulo, tipo, autor, ano, f, alocados);
	printf("\n ***** Titulo REMOVIDO!!! *****\n");
	printf(" Pressione <enter> para retornar ao menu.....");
	getchar();
	system("clear");
	ordenaindice(pk);
	menup(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados); /* Volta para o menu principal */
	return;
      }
      if ( resp == 'n'){
	printf(" Pressione <enter> para retornar ao menu.....");
	getchar();
	system("clear");
	menup(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados); /* Volta para o menu principal */
	return;
      }
      system("clear");
    } else {
      printf("\n ***** Titulo nao encontrado! ***** \n\n");
      getchar();
      printf(" Pressione <enter> para retornar ao menu.....");
      getchar();
      system("clear");
      menup(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados); /* Volta para o menu principal */
      return;
    }
    break;

  case '3':
  case 'b':
  case 'B':
    getchar();
    menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Ir para o menu de Busca */
    break;

  case '4':
  case 'l':
  case 'L':
    /* Lista */
    lista(basept, pk);
    getchar();
    printf("\n\n ***** Listagem impressa no arquivo %s!  *****\n\nPressione <enter> para retornar ao menu...",LISTAHTML);
    getchar();
    system("clear");
    menup(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu principal */
    break;

  case '5':
  case 's':
  case 'S':
    /* Saida */
    ordenaindice(pk);
    strcpy(nomearq, INDPRIM);
    ram2ind(arq, pk, nomearq);         /* Grava os dados da memoria no arquivo PK */
    
    ordenaindice(titulo);
    strcpy(nomearq, TITSK);
    ram2ind(arq, titulo, nomearq); /* Grava os dados da memoria no arquivo de pk TITULO */
    
    ordenaindice(tipo);
    strcpy(nomearq, TIPSK);
    ram2ind(arq, tipo, nomearq);    /* Grava os dados da memoria no arquivo de pk TIPO */
    
    ordenaindice(autor);
    strcpy(nomearq, AUTSK);
    ram2ind(arq, autor, nomearq);   /* Grava os dados da memoria no arquivo de pk AUTOR */

    ordenaindice(ano);
    strcpy(nomearq, ANOSK);
    ram2ind(arq, ano, nomearq);       /* Grava os dados da memoria no arquivo de pk ANO */

    break;

  default:
    /* Em entrada invalida, fecha o programa */
    printf("\n\n Opcao INVALIDA!\n Pressione <enter> para retornar ao menu...");
    getchar(); /* Aguarda o usuario digitar enter, para a visualizacao da mensagem */
    system("clear");
    menup(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu principal */
    break;
  }
  return;
}


/* ------------------------------------------------------------------------------- */

/* Adiciona um registro a base de dados: */
/* Armazena os dados na struct, e os grava no arquivo da base de dados */
/* Chama as funcoes necessarias para atualizacoes de indices e estruturas */
void add(FILE **basept, FILE **arq, reg *dados, tipoindice *pk, tipoindice *titulo, tipoindice *tipo, tipoindice *autor, tipoindice *ano, int *alocados) {

  int cont=0, avail=-1, antigo=-1;
  char opt;
  tipocelsk *f;

  for(cont=0;cont<MAX_TIT;cont++){
    dados->titulo[cont] = '\0';
  }

  for(cont=0;cont<MAX_TIP;cont++){
    dados->tipo[cont] = '\0';
  }

  for(cont=0;cont<MAX_AUT;cont++){
    dados->autor[cont] = '\0';
  }

  for(cont=0;cont<MAX_ANO;cont++){
    dados->ano[cont] = '\0';
  }

  /* Realoca o vetor de celulas, se necessario */
  if(pk->listasktam + 1 > *alocados){
    *alocados = (*alocados)*2;
    pk->listask = (tipocelsk *)realloc(pk->listask, sizeof(tipocelsk)*(*alocados));    
    titulo->listask = (tipocelsk *)realloc(titulo->listask, sizeof(tipocelsk)*(*alocados));  
    tipo->listask = (tipocelsk *)realloc(tipo->listask, sizeof(tipocelsk)*(*alocados));   
    autor->listask = (tipocelsk *)realloc(autor->listask, sizeof(tipocelsk)*(*alocados));    
    ano->listask = (tipocelsk *)realloc(ano->listask, sizeof(tipocelsk)*(*alocados));
  }
  
  system("clear"); /* Limpa a tela do prompt */
  printf("Entre com os dados da obra:\n");

  /* o modificador "%100[^\n]" le a entrada ate o caractere '\n' e 
     garante o limite de 100 caracteres */
  
  /* '__fpurge' limpa o buffer da entrada para a proxima leitura */

  /* Leituras das entradas para a memoria: */
  __fpurge(stdin);
  /* Titulo */
  printf("\nTITULO (%d caracteres): \n ==> ", MAX_TIT);
  scanf(" %200[^\n]",dados->titulo);
  __fpurge(stdin);

  /* Verifica se ja existe a chave primaria no pk */
  f = buscat(pk, dados->titulo);

  if (f != NULL) {
    printf("\n ==> [%s] ja existe!\n", f->sk);
    printf("Pressione ENTER para Inserir outro TITULO...");
    getchar();
    system("clear");
    add(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);
    return;
  }
  
  /* Tipo */
  printf("\nTIPO (%d caracteres): \n ==> ",MAX_TIP);
  scanf(" %100[^\n]",dados->tipo);
  __fpurge(stdin);
  
  /* Autor */
  printf("\nAUTOR (%d caracteres): \n ==> ",MAX_AUT);
  scanf(" %125[^\n]",dados->autor);
  __fpurge(stdin);
  
  /* Ano */
  printf("\nANO (ate %d digitos): \n ==> ",MAX_ANO);
  scanf(" %4[^\n]", dados->ano);
  __fpurge(stdin);

  /* Valor */
  printf("\nVALOR (ate %d digitos): \n ==> ",MAX_VAL);
  scanf(" %12d",&dados->valor);
  __fpurge(stdin);

  /* Imagem */
  printf("\nNOME DA IMAGEM (%d caracteres): \n ==> ",MAX_IMG);
  scanf(" %9[^\n]",dados->imagem);
  __fpurge(stdin);

  /* Insere os dados no final ou no slot vazio da avail list */
  *arq = fopen(AVAILLIST, "r");
  if(*arq != NULL){
    fscanf(*arq, "%04d", &avail);
    fclose(*arq);
  }

  if(avail != -1) { /* Algoritmo para usar o conceito de AVAIL LIST */
    antigo = avail;

    /* Como foi inserido uma nova chave, atualiza o pk, inserindo a nova chave */
    insereindice(arq, dados, pk, titulo, tipo, autor, ano);

    fseek(*basept, (avail*REGTAM)*sizeof(char), SEEK_SET);
    fscanf(*basept, "%c", &opt);
    fscanf(*basept, "%04d", &avail);    
    *arq = fopen(AVAILLIST,"w");
    fprintf(*arq, "%04d", avail);
    fclose(*arq);
    fseek(*basept, (antigo*REGTAM)*sizeof(char), SEEK_SET);
  } else {
    fclose(*basept);
    *basept = fopen(BASE,"a+");
    /* Como foi inserido uma nova chave, atualiza o pk, inserindo a nova chave */
    insereindice(arq, dados, pk, titulo, tipo, autor, ano);
  }

  /* Grava os dados da struct no arquivo de base */
  /* OBS: Os moficadores garantem a impressao do numero certo de caracteres em cada caso */
  fprintf(*basept,"%-200s",dados->titulo);
  fprintf(*basept,"%-100s",dados->tipo);
  fprintf(*basept,"%-125s",dados->autor);
  fprintf(*basept,"%-4s",dados->ano);
  fprintf(*basept,"%012d",dados->valor);
  fprintf(*basept,"%-9s",dados->imagem);

  fclose(*basept); /* FECHA */
  *basept = fopen(BASE,"r+"); /* ABRE */   

  printf("\nDeseja inserir outra obra (s/n)?");
  
  opt = getchar();
  /* Age de acordo com a opcao do usuario */
  switch(opt){
  case 's':
  case 'S':
    add(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados); /* Realiza uma nova insercao  */
    break;
  case 'n':
  case 'N':
    getchar(); /* Elimina o '\n' digitado pelo usuario */ 
    system("clear"); /* Limpa a tela do prompt */
    menup(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu principal */
    break;    
  default:
    printf("\n\n Opcao invalida!\n Pressione <enter> voltar ao menu principal...");
    getchar(); /* Elimina o \n digitado pelo usuario */
    getchar(); /* Aguarda o usuario digitar enter, para a visualizacao da mensagem */
    system("clear");
    menup(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu principal */
    break;
  }
  return;
}


/* ------------------------------------------------------------------------------- */

/* Faz a remocao de um registro pela chave primaria, o apagando na base de dados */
void remocao(FILE **basept, FILE **arq, reg *dados, tipoindice *pk, tipoindice *titulo, tipoindice *tipo, tipoindice *autor, tipoindice *ano, tipocelsk *resbusca, int *alocados) {
  
  int cont=0, x=0, target = 0, posicao=0, antiga=0, antiga2=0, y=0, rem=0, avail=-1;
  char d, palavra[MAX_TIT+1], *quebra;

  target = REGTAM*resbusca->pos;

  while(1) { /* Copia a PK que sera removida  */
    fseek(*basept,target*sizeof(char),SEEK_SET);
    for (cont=0; cont < MAX_TIT; cont++) {
      d = getc(*basept);
      d = tolower(d);
      dados->titulo[cont] = d;
    }
    if (cont == MAX_TIT) break;
  }
  dados->titulo[cont] = '\0';
  
  while(1) { /* Copia o TIPO que sera removida  */
    for (cont=0; cont < MAX_TIP; cont++) {
      d = getc(*basept);
      d = tolower(d);
      dados->tipo[cont] = d;
    }
    if (cont == MAX_TIP) break;
  }
  dados->tipo[cont] = '\0';
  
  while(1) { /* Copia o AUTOR que sera removida  */
    for (cont=0; cont < MAX_AUT; cont++) {
      d = getc(*basept);
      d = tolower(d);
      dados->autor[cont] = d;
    }
    if (cont == MAX_AUT) break;
  }
  dados->autor[cont] = '\0';

  while(1) { /* Copia o ANO que sera removida  */
    for (cont=0; cont < MAX_ANO; cont++) {
      d = getc(*basept);
      d = tolower(d);
      dados->ano[cont] = d;
    }
    if (cont == MAX_ANO) break;
  }
  dados->ano[cont] = '\0';

  *arq = fopen(AVAILLIST,"r"); /* Abre ou Cria o arquivo de AVAIL LIST  */
  if( *arq != NULL) {
    fscanf(*arq, "%04d", &avail); /* Le o ponteiro da AVAIL LIST, caso n tenho nada, ele continua -1 */
    fclose(*arq);
  }

  *arq = fopen(AVAILLIST, "w");

  target = REGTAM*resbusca->pos;
  /* Coloca o PONTEIRO DE AVAIL no primeiro caracter do registro, na base de dados */
  fseek(*basept, target*sizeof(char), SEEK_SET);
  fprintf(*basept, "|%04d", avail);
  for(cont=5; cont < REGTAM; cont++){
    fprintf(*basept, "*");
  }

  fseek(*arq, 0, 0);
  fprintf(*arq, "%04d", resbusca->pos); /* Grava o NRR q sera removido, pra utilizar a AVAIL LIST */

  for(cont=0;cont < pk->listasktam;cont++){ /* Procura na RAM qual a posicao da obra a ser removida  */
    if(strcmp(dados->titulo, pk->listask[cont].sk) == 0) break;
  }

  rem = cont; /* REM = posicao da OBRA a ser removida  */

  fclose(*arq);  /* Fecha o arquivo de AVAIL LIST */

  /* ------------------------------------------TITULO------------------------------------------------------------------- */

  *arq = fopen(TITPK,"r+");

  quebra = strtok(dados->titulo," ,.-");

  while (quebra != NULL){

    y=0;
    for(x=0;x<titulo->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
      if(strcmp(quebra, titulo->listask[x].sk) == 0){
	break;
      }
    }

    posicao = (MAX_TIT + TAMPOSREL)*titulo->listask[x].pos;
    antiga = posicao;
    y=0;
    while(1){
      
      fseek(*arq, posicao*sizeof(char), 0);
      fscanf(*arq, "%04d", &posicao); /* Le qual sera a prox posicao */
      fscanf(*arq, "%200[^\n]", palavra);
      
      if( strcmp(palavra, pk->listask[rem].sk) == 0 ){ /* Se a PK relacionada jah for a encontrada no INDPRIM, atualiza  */

	if(y == 0 && posicao == -1){
	  strcpy(titulo->listask[x].sk, "zzzzz"); /* Se a 1 PK for a removida, e apontar pra -001, remove na SK */
	  ordenaindice(titulo); /* A SK a ser removida, vai para ultima pos do vetor, ai sim ela eh deletada  */
	  titulo->listasktam--; /* Diminui o tamanho da lista de SKs */
	  fseek(*arq, antiga*sizeof(char), 0);
	  fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	  break;
	}
	if(y == 0) {
	  titulo->listask[x].pos = posicao; /* Se a 1 PK for a removida, atualiza a SK  */
	  fseek(*arq, antiga*sizeof(char), 0);
	  fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	  break;
	}
	fseek(*arq, antiga*sizeof(char), 0);
	fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	fseek(*arq, antiga2*sizeof(char), 0);
	fprintf(*arq, "%04d", posicao); /* Atualiza a prox posicao  */
      }

      y++;
      if(posicao == -1) break;
      antiga2 = antiga;
      antiga = posicao*(MAX_TIT + TAMPOSREL);
      posicao = posicao*(MAX_TIT + TAMPOSREL);

    }


    quebra = strtok(NULL, " ,.-");

  }

  fclose(*arq);

  /* --------------------------------------------TIPO------------------------------------------------------------------- */

  *arq = fopen(TIPPK,"r+");

  quebra = strtok(dados->tipo," ,.-");

  while (quebra != NULL){

    y=0;
    for(x=0;x<tipo->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
      if(strcmp(quebra, tipo->listask[x].sk) == 0){
	break;
      }
    }

    posicao = (MAX_TIT + TAMPOSREL)*tipo->listask[x].pos;
    antiga = posicao;
    y=0;
    while(1){
      
      fseek(*arq, posicao*sizeof(char), 0);
      fscanf(*arq, "%04d", &posicao); /* Le qual sera a prox posicao */
      fscanf(*arq, "%200[^\n]", palavra);
      
      if( strcmp(palavra, pk->listask[rem].sk) == 0 ){ /* Se a PK relacionada jah for a encontrada no INDPRIM, atualiza  */
	
	if(y == 0 && posicao == -1){
	  strcpy(tipo->listask[x].sk, "zzzzz"); /* Se a 1 PK for a removida, e apontar pra -001, remove na SK */
	  ordenaindice(tipo); /* A SK a ser removida, vai para ultima pos do vetor, ai sim ela eh deletada  */
	  tipo->listasktam--; /* Diminui o tamanho da lista de SKs */
	  fseek(*arq, antiga*sizeof(char), 0);
	  fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	  break;
	}
	if(y == 0) {
	  tipo->listask[x].pos = posicao; /* Se a 1 PK for a removida, atualiza a SK  */
	  fseek(*arq, antiga*sizeof(char), 0);
	  fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	  break;
	}
	fseek(*arq, antiga*sizeof(char), 0);
	fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	fseek(*arq, antiga2*sizeof(char), 0);
	fprintf(*arq, "%04d", posicao); /* Coloca um -002 na PK q n será mais utilizada  */
      }

      y++;
      if(posicao == -1) break;
      antiga2 = antiga;
      antiga = posicao*(MAX_TIT + TAMPOSREL);
      posicao = posicao*(MAX_TIT + TAMPOSREL);

    }


    quebra = strtok(NULL, " ,.-");

  }

  fclose(*arq);


  /* -------------------------------------------------AUTOR------------------------------------------------------------- */
  
  *arq = fopen(AUTPK,"r+");
  
  quebra = strtok(dados->autor," ,.-");

  while (quebra != NULL){

    y=0;
    for(x=0;x<autor->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
      if(strcmp(quebra, autor->listask[x].sk) == 0){
	break;
      }
    }

    posicao = (MAX_TIT + TAMPOSREL)*autor->listask[x].pos;
    antiga = posicao;
    y=0;
    while(1){
      
      fseek(*arq, posicao*sizeof(char), 0);
      fscanf(*arq, "%04d", &posicao); /* Le qual sera a prox posicao */
      fscanf(*arq, "%200[^\n]", palavra);
      
      if( strcmp(palavra, pk->listask[rem].sk) == 0 ){ /* Se a PK relacionada jah for a encontrada no INDPRIM, atualiza  */
	
	if(y == 0 && posicao == -1){
	  strcpy(autor->listask[x].sk, "zzzzz"); /* Se a 1 PK for a removida, e apontar pra -001, remove na SK */
	  ordenaindice(autor); /* A SK a ser removida, vai para ultima pos do vetor, ai sim ela eh deletada  */
	  autor->listasktam--; /* Diminui o tamanho da lista de SKs */
	  fseek(*arq, antiga*sizeof(char), 0);
	  fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	  break;
	}
	if(y == 0) {
	  autor->listask[x].pos = posicao; /* Se a 1 PK for a removida, atualiza a SK  */
	  fseek(*arq, antiga*sizeof(char), 0);
	  fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	  break;
	}
	fseek(*arq, antiga*sizeof(char), 0);
	fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	fseek(*arq, antiga2*sizeof(char), 0);
	fprintf(*arq, "%04d", posicao); /* Coloca um -002 na PK q n será mais utilizada  */
      }

      y++;
      if(posicao == -1) break;
      antiga2 = antiga;
      antiga = posicao*(MAX_TIT + TAMPOSREL);
      posicao = posicao*(MAX_TIT + TAMPOSREL);

    }


    quebra = strtok(NULL, " ,.-");

  }

  fclose(*arq);

  /* -----------------------------------------------ANO---------------------------------------------------------------- */

  *arq = fopen(ANOPK,"r+");

  quebra = strtok(dados->ano," ,.-");

  while (quebra != NULL){

    y=0;
    for(x=0;x<ano->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
      if(strcmp(quebra, ano->listask[x].sk) == 0){
	break;
      }
    }

    posicao = (MAX_TIT + TAMPOSREL)*ano->listask[x].pos;
    antiga = posicao;
    y=0;
    while(1){
      
      fseek(*arq, posicao*sizeof(char), 0);
      fscanf(*arq, "%04d", &posicao); /* Le qual sera a prox posicao */
      fscanf(*arq, "%200[^\n]", palavra);
      
      if( strcmp(palavra, pk->listask[rem].sk) == 0 ){ /* Se a PK relacionada jah for a encontrada no INDPRIM, atualiza  */
	if(y == 0 && posicao == -1){
	  strcpy(ano->listask[x].sk, "zzzzz"); /* Se a 1 PK for a removida, e apontar pra -001, remove na SK */
	  ordenaindice(ano); /* A SK a ser removida, vai para ultima pos do vetor, ai sim ela eh deletada  */
	  ano->listasktam--; /* Diminui o tamanho da lista de SKs */
	  fseek(*arq, antiga*sizeof(char), 0);
	  fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	  break;
	}
	if(y == 0) {
	  ano->listask[x].pos = posicao; /* Se a 1 PK for a removida, atualiza a SK  */
	  fseek(*arq, antiga*sizeof(char), 0);
	  fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	  break;
	}
	fseek(*arq, antiga*sizeof(char), 0);
	fprintf(*arq, "%04d", -2); /* Coloca um -002 na PK q n será mais utilizada  */
	fseek(*arq, antiga2*sizeof(char), 0);
	fprintf(*arq, "%04d", posicao); /* Coloca um -002 na PK q n será mais utilizada  */
      }

      y++;
      if(posicao == -1) break;
      antiga2 = antiga;
      antiga = posicao*(MAX_TIT + TAMPOSREL);
      posicao = posicao*(MAX_TIT + TAMPOSREL);

    }


    quebra = strtok(NULL, " ,.-");

  }

  fclose(*arq);


  /* --------------------------------------------------PK----------------------------------------------------------------- */


  /* Coloca * no INDPRIM para o indice primario */
  for(cont=0; cont < pk->listasktam; cont++){
    if (pk->listask[cont].pos == resbusca->pos){
      strcpy(pk->listask[cont].sk, "zzzzz");
      ordenaindice(pk);
      pk->listasktam--;
    }
  }
  
  return;
  
}


/* ------------------------------------------------------------------------------- */

/* Carrega o arquivo .ind para a memoria */
void ind2ram(FILE **arq, tipoindice *pk, char *nomearq, int *alocados) {

  int cont=0, target=0, linha=-1;
  char tmp[MAX_TIT+1];

  *arq = fopen(nomearq,"r"); /* ABRE ARQUIVO GENERICO */

  if(strcmp(nomearq, INDPRIM) == 0){ /* Caso seja o ARQUIVO de PKs, a leitura sera diferente  */
    while(!feof(*arq)){
      fseek(*arq,target*sizeof(char),SEEK_SET);
      fscanf(*arq, "%04d", &cont);
      fscanf(*arq, "%200[^\n]", tmp);
      target += (MAX_TIT + TAMPOSREL);
      linha++;
    }
  }
  
  if(strcmp(nomearq, INDPRIM) != 0){
    fseek(*arq, 0, 0);
    linha=-1;
    target=0;
    while(!feof(*arq)) {
      fseek(*arq,target*sizeof(char),SEEK_CUR);
      fscanf(*arq, "%04d", &cont);
      fscanf(*arq, "%[^\n]", tmp);
      linha++;
    }
  }
  
  /* Realoca memoria quando necessario */
  if((linha+1) > *alocados){
    while((linha+1) > *alocados){
      (*alocados) = (*alocados) * 2;
    }
    pk->listask = (tipocelsk *)realloc(pk->listask, sizeof(tipocelsk)*(*alocados));
  }
  else {
    pk->listask = (tipocelsk *)realloc(pk->listask, sizeof(tipocelsk)*(*alocados));
  }

  pk->listasktam = linha;
  fseek(*arq, 0, 0);
  target=0;
  cont=0;

  if(strcmp(nomearq, INDPRIM) == 0){ /* Caso seja o ARQUIVO de PKs, a leitura sera diferente  */
    pk->listasktam=-1;
    while(!feof(*arq)){
      fseek(*arq,target*sizeof(char),SEEK_SET);
      fscanf(*arq, "%04d", &pk->listask[cont].pos);
      fscanf(*arq, "%200[^\n]", pk->listask[cont].sk);
      cont++;
      target += (MAX_TIT + TAMPOSREL);
      pk->listasktam++;
    }
    fclose(*arq);

    return;
  }

  fseek(*arq,0,0);
  cont=0;

  while(!feof(*arq)){
    fscanf(*arq, "%04d", &pk->listask[cont].pos);
    if(pk->listapktam <= pk->listask[cont].pos) pk->listapktam = pk->listask[cont].pos;
    fscanf(*arq, "%[^\n]", pk->listask[cont].sk);
    cont++;
  }

  fclose(*arq); /* FECHA ARQUIVO GENERICO */
    
  return;
}

/* ------------------------------------------------------------------------------- */

/* Grava da memoria no arquivo .ind */
void ram2ind(FILE **arq, tipoindice *pk, char *nomearq) {

  int cont=0;
  *arq = fopen(nomearq,"w"); /* ABRE ARQUIVO GENERICO */

  if(strcmp(nomearq, INDPRIM) == 0){
    for(cont=0;cont < pk->listasktam;cont++){
      fprintf(*arq, "%04d", pk->listask[cont].pos);
      fprintf(*arq, "%s", pk->listask[cont].sk);
    }
    fclose(*arq); /* FECHA ARQUIVO de PKs */
    return;
  }

  for(cont=0;cont < pk->listasktam;cont++){
    fprintf(*arq, "%04d", pk->listask[cont].pos);
    fprintf(*arq, "%s\n", pk->listask[cont].sk);
  }

  fclose(*arq); /* FECHA ARQUIVO GENERICO */
  return;
}

/* ------------------------------------------------------------------------------- */

/* Funcao auxiliar para o qsort */
int compara(const void *a, const void *b) {

  struct t_registro {
    char nome[MAX_TIT];
    int NRR;
  };

  struct t_registro *reg_1, *reg_2;

  reg_1 = (struct t_registro *) a;
  reg_2 = (struct t_registro *) b;
 
     
  /* Ordena pelo nome, ordem crescente */
  return (strcmp(reg_1->nome,reg_2->nome));
}


/* ------------------------------------------------------------------------------- */

/* Ordena um indice usando o quicksort e uma funcao auxiliar 'compara' */
void ordenaindice(tipoindice *pk) {

  typedef struct {
    char nome[MAX_TIT];
    int pos;
    int NRR;
  } t_registro;

  int cont=0,linha=0;
  t_registro *matriz;
  matriz=(t_registro *)malloc(sizeof(t_registro)*pk->listasktam);

  for(linha=0; linha < pk->listasktam; linha++){
    strcpy(matriz[linha].nome, pk->listask[linha].sk); /* Copia Titulo */
    matriz[linha].NRR = pk->listask[linha].pos;  /* Copia NRR */
  }

  qsort(matriz,pk->listasktam,sizeof(t_registro),compara);

  for(cont=0; cont < pk->listasktam; cont++){
    strcpy(pk->listask[cont].sk, matriz[cont].nome); /* Atualiza Titulos */
    pk->listask[cont].pos = matriz[cont].NRR;  /* Atualiza NRRs */
  }
  free(matriz);
}


/* ------------------------------------------------------------------------------- */

/* Cria todos os indices necessarios a partir do banco de dados */
/* Obs: essa funcao eh chamada apenas quando os indices nao existem */
void criaindice(FILE **basept, FILE **arq, tipoindice *pk, tipoindice *titulo, tipoindice *tipo, tipoindice *autor, tipoindice *ano, int *alocados) {
  char *quebra, nomearq[NOMEARQTAM];
  
  /* Estrutura auxiliar para armazenar as chaves */
  typedef struct {
    char nome[MAX_TIT+1];
    int NRR;
  } t_registro;

  t_registro *matriz;

  int cont=0,espaco=0,target=0,linha=0,x=0, y=0;
  char d;
  
  /* linha -> contador do tamanho do arquivo base.dat */
  while(!feof(*basept)){    
    fseek(*basept,target*sizeof(char),SEEK_SET);
    d = getc(*basept);
    if (d == EOF) break;
    linha++;
    target += REGTAM;
  }
  
  espaco = linha;
  matriz = (t_registro *)malloc(sizeof(t_registro)*(linha));

  /* Realoca os vetores de celulas, se necessario ------------------ */
  if(linha + 1 > *alocados){
        
    while(linha + 1 > *alocados){
      *alocados = (*alocados)*2;
    }
    pk->listask = (tipocelsk *)realloc(pk->listask, sizeof(tipocelsk)*(*alocados));
    titulo->listask = (tipocelsk *)realloc(titulo->listask, sizeof(tipocelsk)*(*alocados));
    tipo->listask = (tipocelsk *)realloc(tipo->listask, sizeof(tipocelsk)*(*alocados));
    autor->listask = (tipocelsk *)realloc(autor->listask, sizeof(tipocelsk)*(*alocados));
    ano->listask = (tipocelsk *)realloc(ano->listask, sizeof(tipocelsk)*(*alocados));
    matriz = (t_registro *)realloc(matriz, sizeof(t_registro)*(linha));
  }

  /* ------------------------------------------------------------------ */

  target = 0;
  linha = 0;

  while(1) {
    fseek(*basept,target*sizeof(char),SEEK_SET);
    
    /* Procura por dois caracteres 'espaço' seguidos e os considera como fim de string */
    for (cont=0; cont < MAX_TIT; cont++) {
      d = getc(*basept);
      if (d == EOF) break;
      d = tolower(d);
      matriz[linha].nome[cont] = d;
      matriz[linha].NRR = linha;
    }
    if (d == EOF) break;
    linha++;
    target += REGTAM;
  }

  pk->listapktam = linha;

  for(cont=0;cont < pk->listapktam;cont++){
    strcpy(pk->listask[cont].pk, matriz[cont].nome);
    pk->listask[cont].pos = matriz[cont].NRR;
  }

  *arq = fopen(INDPRIM,"w");
  for(cont=0;cont < linha;cont++) { /* Grava os TITULOS no arquivo de chaves primárias  */
    fprintf(*arq,"%04d%s", pk->listask[cont].pos, pk->listask[cont].pk);
  }
  fclose(*arq);

  /* gravar PK e prox da SK */ 

  for(cont=0; cont < linha; cont++){
    titulo->listask[cont].pos = -1;
  }

  titulo->listasktam = 0; /* TAMANHO do Arquivo de SKs  */
  titulo->listapktam = 0; /* TAMANHO do Arquivo de PKs  */

  *arq = fopen(TITPK,"w");

  y=0;
  x=0;
  for(cont=0;cont < linha;cont++) { /* FOR para separar as strings */
    quebra = strtok(matriz[cont].nome," ,.-");

    while (quebra != NULL){
      y=0;
      for(x=0;x<titulo->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
	if(strcmp(quebra, titulo->listask[x].sk) == 0){
	  y=1;
	  break;
	}
      }

      if(y == 0){ /* Se nao existe, grava a SK na RAM e aumenta o tamanho...e grava a PK relacionada */
	strcpy(titulo->listask[titulo->listasktam].sk, quebra);
	fprintf(*arq, "%04d%s", -1, pk->listask[cont].pk); /* Grava no arq de PKs relacionadas com o -1 pois n existe a SK */
	titulo->listask[titulo->listasktam].pos = titulo->listapktam; /* A posicao da SK recebe a posicao relativa em DISCO */
	titulo->listasktam++; /* Aumenta o tamanho do arquivo de SKs */
	titulo->listapktam++; /* Aumenta o tamanho em DISCO  */
      }
      
      if(y != 0){ /* Se existe, pega a POS da SK e a substitui pelo tamanho da lista em DISCO */
	fprintf(*arq, "%04d%s", titulo->listask[x].pos, pk->listask[cont].pk);
	titulo->listask[x].pos = titulo->listapktam;
	titulo->listapktam++; /* Aumenta o tamanho em DISCO  */
      }
      quebra = strtok(NULL, " ,.-");
    }
  }

  fclose(*arq);

  *arq = fopen(TITSK,"w");

  for(cont=0; cont < titulo->listasktam; cont++){
    fprintf(*arq, "%04d%s\n", titulo->listask[cont].pos, titulo->listask[cont].sk);
  }

  fclose(*arq);
    
  /*------------------------TIPO----------------------------------------------------------*/

  target = MAX_TIT;
  linha = 0;

  while(1) {
    fseek(*basept,target*sizeof(char),SEEK_SET);
    
    /* Procura por dois caracteres 'espaço' seguidos e os considera como fim de string */
    for (cont=0; cont < MAX_TIP; cont++) {
      d = getc(*basept);
      if (d == EOF) break;
      d = tolower(d);
      matriz[linha].nome[cont] = d;
      matriz[linha].NRR = linha;
    }
    if (d == EOF) break;
    linha++;
    target += REGTAM;
  }

  /* gravar PK e prox da SK */ 

  for(cont=0; cont < linha; cont++){
    tipo->listask[cont].pos = -1;
  }

  tipo->listasktam = 0; /* TAMANHO do Arquivo de SKs  */
  tipo->listapktam = 0; /* TAMANHO do Arquivo de PKs  */

  *arq = fopen(TIPPK,"w");

  y=0;
  x=0;
  for(cont=0;cont < linha;cont++) { /* FOR para separar as strings */
    quebra = strtok(matriz[cont].nome," ,.-");

    while (quebra != NULL){
      y=0;
      for(x=0;x<tipo->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
	if(strcmp(quebra, tipo->listask[x].sk) == 0){
	  y=1;
	  break;
	}
      }
      
      if(y == 0){ /* Se nao existe, grava a SK na RAM e aumenta o tamanho...e grava a PK relacionada */
	strcpy(tipo->listask[tipo->listasktam].sk, quebra);
	fprintf(*arq, "%04d%s", -1, pk->listask[cont].pk); /* Grava no arq de PKs relacionadas com o -1 pois n existe a SK */
	tipo->listask[tipo->listasktam].pos = tipo->listapktam; /* A posicao da SK recebe a posicao relativa em DISCO */
	tipo->listasktam++; /* Aumenta o tamanho do arquivo de SKs */
	tipo->listapktam++; /* Aumenta o tamanho em DISCO  */
      }
      
      if(y != 0){ /* Se existe, pega a POS da SK e a substitui pelo tamanho da lista em DISCO */
	fprintf(*arq, "%04d%s", tipo->listask[x].pos, pk->listask[cont].pk);
	tipo->listask[x].pos = tipo->listapktam;
	tipo->listapktam++; /* Aumenta o tamanho em DISCO  */
      }
      quebra = strtok(NULL, " ,.-");
    }
  }

  fclose(*arq);

  *arq = fopen(TIPSK,"w");

  for(cont=0; cont < tipo->listasktam; cont++){
    fprintf(*arq, "%04d%s\n", tipo->listask[cont].pos, tipo->listask[cont].sk);
  }

  fclose(*arq);

  /*------------------------AUTOR---------------------------------------------------------*/

  target = MAX_TIT+MAX_TIP; 
  linha = 0;

  while(1) {
    fseek(*basept,target*sizeof(char),SEEK_SET);
    
    /* Procura por dois caracteres 'espaço' seguidos e os considera como fim de string */
    for (cont=0; cont < MAX_AUT; cont++) {
      d = getc(*basept);
      if (d == EOF) break;
      d = tolower(d);
      matriz[linha].nome[cont] = d;
      matriz[linha].NRR = linha;
    }
    if (d == EOF) break;
    linha++;
    target += REGTAM;
  }

  /* gravar PK e prox da SK */ 

  for(cont=0; cont < linha; cont++){
    autor->listask[cont].pos = -1;
  }

  autor->listasktam = 0; /* TAMANHO do Arquivo de SKs  */
  autor->listapktam = 0; /* TAMANHO do Arquivo de PKs  */

  *arq = fopen(AUTPK,"w");

  y=0;
  x=0;
  for(cont=0;cont < linha;cont++) { /* FOR para separar as strings */
    quebra = strtok(matriz[cont].nome," ,.-");

    while (quebra != NULL){
      y=0;
      for(x=0;x<autor->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
	if(strcmp(quebra, autor->listask[x].sk) == 0){
	  y=1;
	  break;
	}
      }
      
      if(y == 0){ /* Se nao existe, grava a SK na RAM e aumenta o tamanho...e grava a PK relacionada */
	strcpy(autor->listask[autor->listasktam].sk, quebra);
	fprintf(*arq, "%04d%s", -1, pk->listask[cont].pk); /* Grava no arq de PKs relacionadas com o -1 pois n existe a SK */
	autor->listask[autor->listasktam].pos = autor->listapktam; /* A posicao da SK recebe a posicao relativa em DISCO */
	autor->listasktam++; /* Aumenta o tamanho do arquivo de SKs */
	autor->listapktam++; /* Aumenta o tamanho em DISCO  */
      }
      
      if(y != 0){ /* Se existe, pega a POS da SK e a substitui pelo tamanho da lista em DISCO */
	fprintf(*arq, "%04d%s", autor->listask[x].pos, pk->listask[cont].pk);
	autor->listask[x].pos = autor->listapktam;
	autor->listapktam++; /* Aumenta o tamanho em DISCO  */
      }
      quebra = strtok(NULL, " ,.-");
    }
  }

  fclose(*arq);

  *arq = fopen(AUTSK,"w");

  for(cont=0; cont < autor->listasktam; cont++){
    fprintf(*arq, "%04d%s\n", autor->listask[cont].pos, autor->listask[cont].sk);
  }

  fclose(*arq);

  /*------------------------ANO-----------------------------------------------------------*/

  target = MAX_TIT+MAX_TIP+MAX_AUT;

  for(linha=0; linha < espaco; linha++){
    for(cont=0; cont < MAX_TIT; cont++){
      matriz[linha].nome[cont] = '\0';
    }
  }

  target = MAX_TIT+MAX_TIP+MAX_AUT; 
  linha = 0;

  while(1) {
    fseek(*basept,target*sizeof(char),SEEK_SET);
    
    /* Procura por dois caracteres 'espaço' seguidos e os considera como fim de string */
    for (cont=0; cont < MAX_ANO; cont++) {
      d = getc(*basept);
      if (d == EOF) break;
      d = tolower(d);
      matriz[linha].nome[cont] = d;
      matriz[linha].NRR = linha;
    }
    if (d == EOF) break;
    linha++;
    target += REGTAM;
  }
  
  /* gravar PK e prox da SK */ 

  for(cont=0; cont < linha; cont++){
    ano->listask[cont].pos = -1;
  }

  ano->listasktam = 0; /* TAMANHO do Arquivo de SKs  */
  ano->listapktam = 0; /* TAMANHO do Arquivo de PKs  */

  *arq = fopen(ANOPK,"w");

  y=0;
  x=0;
  for(cont=0;cont < linha;cont++) { /* FOR para separar as strings */
    quebra = strtok(matriz[cont].nome," ,.-");

    while (quebra != NULL){
      y=0;
      for(x=0;x<ano->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
	if(strcmp(quebra, ano->listask[x].sk) == 0){
	  y=1;
	  break;
	}
      }
      
      if(y == 0){ /* Se nao existe, grava a SK na RAM e aumenta o tamanho...e grava a PK relacionada */
	strcpy(ano->listask[ano->listasktam].sk, quebra);
	fprintf(*arq, "%04d%s", -1, pk->listask[cont].pk); /* Grava no arq de PKs relacionadas com o -1 pois n existe a SK */
	ano->listask[ano->listasktam].pos = ano->listapktam; /* A posicao da SK recebe a posicao relativa em DISCO */
	ano->listasktam++; /* Aumenta o tamanho do arquivo de SKs */
	ano->listapktam++; /* Aumenta o tamanho em DISCO  */
      }
      
      if(y != 0){ /* Se existe, pega a POS da SK e a substitui pelo tamanho da lista em DISCO */
	fprintf(*arq, "%04d%s", ano->listask[x].pos, pk->listask[cont].pk);
	ano->listask[x].pos = ano->listapktam;
	ano->listapktam++; /* Aumenta o tamanho em DISCO  */
      }
      quebra = strtok(NULL, " ,.-");
    }
  }

  fclose(*arq);

  *arq = fopen(ANOSK,"w");

  for(cont=0; cont < ano->listasktam; cont++){
    fprintf(*arq, "%04d%s\n", ano->listask[cont].pos, ano->listask[cont].sk);
  }

  fclose(*arq);

  free(matriz);

  /*--------------------------------------------------------------------------------------*/

  strcpy(nomearq, INDPRIM);
  ind2ram(arq, pk, nomearq, alocados); /* Carrega os dados do pk para a memoria */
  ordenaindice(pk);
 
  strcpy(nomearq, TITSK);
  ind2ram(arq, titulo, nomearq, alocados); /* Carrega os dados do pk de TITULO para a memoria */
  ordenaindice(titulo);
  
  strcpy(nomearq, TIPSK);
  ind2ram(arq, tipo, nomearq, alocados); /* Carrega os dados do pk de TIPO para a memoria */
  ordenaindice(tipo);
 
  strcpy(nomearq, AUTSK);
  ind2ram(arq, autor, nomearq, alocados); /* Carrega os dados do pk de AUTOR para a memoria */
  ordenaindice(autor);
  
  strcpy(nomearq, ANOSK);
  ind2ram(arq, ano, nomearq, alocados); /* Carrega os dados do pk de ANO para a memoria */
  ordenaindice(ano);
  
  return;
}


/* ------------------------------------------------------------------------------- */

/* Atualiza os indices, quando ha insercao de dados, e os ordena */
void insereindice(FILE **arq, reg *dados, tipoindice *pk, tipoindice *titulo, tipoindice *tipo, tipoindice *autor, tipoindice *ano) {

  int cont=0, x=0, y=0, avail=-1;
  char d, *quebra, aux_quebra[MAX_TIT+1];

  while(1){ /* TO-LOWER pra TITULO  */
    d = dados->titulo[cont];
    if (cont >= MAX_TIT) break;
    d = tolower(d);
    dados->titulo[cont] = d;
    cont++;
  }

  cont=0;
  while(1){ /* TO-LOWER pra TIPO  */
    d = dados->tipo[cont];
    if (cont >= MAX_TIP) break;
    d = tolower(d);
    dados->tipo[cont] = d;
    cont++;
  }

  cont=0;
  while(1){ /* TO-LOWER pra AUTOR */
    d = dados->autor[cont];
    if (cont >= MAX_AUT) break;
    d = tolower(d);
    dados->autor[cont] = d;
    cont++;
  }

  cont=0;
  while(1){ /* TO-LOWER pra ANO  */
    d = dados->ano[cont];
    if (cont >= MAX_ANO) break;
    d = tolower(d);
    dados->ano[cont] = d;
    cont++;
  }

  x=strlen(dados->titulo);

  for(cont=x; cont < MAX_TIT; cont++){
    dados->titulo[cont] = ' ';
  }
  dados->titulo[cont] = '\0';

  /* Insere os dados no final ou no slot vazio da avail list */
  *arq = fopen(AVAILLIST, "r");
  if(*arq != NULL){
    fscanf(*arq, "%04d", &avail);
    fclose(*arq);
  }

  if(avail != -1) { /* Algoritmo para usar o conceito de AVAIL LIST */

    for(cont=0; cont < pk->listasktam; cont++){
      if(pk->listask[cont].pos == avail) break;
    }
    strcpy(pk->listask[cont].sk, dados->titulo);
    pk->listask[cont].pos = avail;
    pk->listasktam++;

  } else {
  /* Copia a entrada para inseri-la no Indice Primario */
  strcpy(pk->listask[pk->listasktam].sk, dados->titulo);
  pk->listask[pk->listasktam].pos = pk->listasktam;
  pk->listasktam++;

  }

  ordenaindice(pk); /* Reoordena o pk de chaves */


  /* --------------------------------TITULO-------------------------------------  */

  x=0;

  *arq = fopen(TITPK, "a+");
  
  strcpy(aux_quebra, dados->titulo);

  quebra = strtok(aux_quebra," ,.-");
  
  while (quebra != NULL){
    y=0;
    for(x=0;x<titulo->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
      if(strcmp(quebra, titulo->listask[x].sk) == 0){
	y=1;
	break;
      }
    }
      
    if(y == 0){ /* Se nao existe, grava a SK na RAM e aumenta o tamanho...e grava a PK relacionada */
      strcpy(titulo->listask[titulo->listasktam].sk, quebra);
      fprintf(*arq, "%04d%s", -1, dados->titulo); /* Grava no arq de PKs relacionadas com o -1 pois n existe a SK */
      titulo->listask[titulo->listasktam].pos = titulo->listapktam;
      titulo->listasktam++; /* Aumenta o tamanho do arquivo de SKs */
      titulo->listapktam++; /* Aumenta o tamanho em DISCO  */
    }
      
    if(y != 0){ /* Se existe, pega a POS da SK e a substitui pelo tamanho da lista em DISCO */
      fprintf(*arq, "%04d%s", titulo->listask[x].pos, dados->titulo);
      titulo->listask[x].pos = titulo->listapktam;
      titulo->listapktam++; /* Aumenta o tamanho em DISCO  */
    }
    quebra = strtok(NULL, " ,.-");
  }

  fclose(*arq);
  
  /* --------------------------------TIPO-------------------------------------  */

  x=0;

  *arq = fopen(TIPPK, "a+");

  strcpy(aux_quebra, dados->tipo);

  quebra = strtok(aux_quebra," ,.-");
  
  while (quebra != NULL){
    y=0;
    for(x=0;x<tipo->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
      if(strcmp(quebra, tipo->listask[x].sk) == 0){
	y=1;
	break;
      }
    }
      
    if(y == 0){ /* Se nao existe, grava a SK na RAM e aumenta o tamanho...e grava a PK relacionada */
      strcpy(tipo->listask[tipo->listasktam].sk, quebra);
      fprintf(*arq, "%04d%s", -1, dados->titulo); /* Grava no arq de PKs relacionadas com o -1 pois n existe a SK */
      tipo->listask[tipo->listasktam].pos = tipo->listapktam;
      tipo->listasktam++; /* Aumenta o tamanho do arquivo de SKs */
      tipo->listapktam++; /* Aumenta o tamanho em DISCO  */
    }
      
    if(y != 0){ /* Se existe, pega a POS da SK e a substitui pelo tamanho da lista em DISCO */
      fprintf(*arq, "%04d%s", tipo->listask[x].pos, dados->titulo);
      tipo->listask[x].pos = tipo->listapktam;
      tipo->listapktam++; /* Aumenta o tamanho em DISCO  */
    }
    quebra = strtok(NULL, " ,.-");
  }

  fclose(*arq);
  
  /* --------------------------------AUTOR-------------------------------------  */

  x=0;

  *arq = fopen(AUTPK, "a+");

  strcpy(aux_quebra, dados->autor);

  quebra = strtok(aux_quebra," ,.-");
  
  while (quebra != NULL){
    y=0;
    for(x=0;x<autor->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
      if(strcmp(quebra, autor->listask[x].sk) == 0){
	y=1;
	break;
      }
    }
      
    if(y == 0){ /* Se nao existe, grava a SK na RAM e aumenta o tamanho...e grava a PK relacionada */
      strcpy(autor->listask[autor->listasktam].sk, quebra);
      fprintf(*arq, "%04d%s", -1, dados->titulo); /* Grava no arq de PKs relacionadas com o -1 pois n existe a SK */
      autor->listask[autor->listasktam].pos = autor->listapktam;
      autor->listasktam++; /* Aumenta o tamanho do arquivo de SKs */
      autor->listapktam++; /* Aumenta o tamanho em DISCO  */
    }
      
    if(y != 0){ /* Se existe, pega a POS da SK e a substitui pelo tamanho da lista em DISCO */
      fprintf(*arq, "%04d%s", autor->listask[x].pos, dados->titulo);
      autor->listask[x].pos = autor->listapktam;
      autor->listapktam++; /* Aumenta o tamanho em DISCO  */
    }
    quebra = strtok(NULL, " ,.-");
  }

  fclose(*arq);

  /* --------------------------------ANO-------------------------------------  */

  x=0;

  *arq = fopen(ANOPK, "a+");

  strcpy(aux_quebra, dados->ano);

  quebra = strtok(aux_quebra," ,.-");
  
  while (quebra != NULL){
    y=0;
    for(x=0;x<ano->listasktam;x++){ /* Ve se a SK jah existe na RAM  */
      if(strcmp(quebra, ano->listask[x].sk) == 0){
	y=1;
	break;
      }
    }
      
    if(y == 0){ /* Se nao existe, grava a SK na RAM e aumenta o tamanho...e grava a PK relacionada */
      strcpy(ano->listask[ano->listasktam].sk, quebra);
      fprintf(*arq, "%04d%s", -1, dados->titulo); /* Grava no arq de PKs relacionadas com o -1 pois n existe a SK */
      ano->listask[ano->listasktam].pos = ano->listapktam;
      ano->listasktam++; /* Aumenta o tamanho do arquivo de SKs */
      ano->listapktam++; /* Aumenta o tamanho em DISCO  */
    }
      
    if(y != 0){ /* Se existe, pega a POS da SK e a substitui pelo tamanho da lista em DISCO */
      fprintf(*arq, "%04d%s", ano->listask[x].pos, dados->titulo);
      ano->listask[x].pos = ano->listapktam;
      ano->listapktam++; /* Aumenta o tamanho em DISCO  */
    }
    quebra = strtok(NULL, " ,.-");
  }

  fclose(*arq);
  
}


/* ------------------------------------------------------------------------------- */

/* Busca por chave primaria */
tipocelsk * buscat(tipoindice *pk, char *target) {
 
  int cont;
  char d;
 
  tipocelsk alvo;
  tipocelsk *f;

  ordenaindice(pk); /* Reoordena o pk de chaves */
 
  cont = 0;

  while(1){
    d = target[cont];
    if (cont >= MAX_TIT) break;
    d = tolower(d);
    target[cont] = d;
    cont++;
  }

  strcpy(alvo.sk, target);

  f = bsearch(&alvo.sk, pk->listask, pk->listasktam, sizeof(tipocelsk), aux_bsearch);

  /* Retorna o NRR do titulo encontrado, e caso nao encontre, retorna NULL */
  if (f != NULL) {
    return f;
  } else {
    return NULL;
  }
}


/* ------------------------------------------------------------------------------- */

/* Faz a listagem completa das obras do banco de dados em um arquivo html */
void lista(FILE **basept, tipoindice *pk) {

  int pos, cimg, x=0;
  int i, j, auxind=0, spc=0;
  char let;
  FILE *arq; /* Arquivo html */
 
  struct registro {
    char tit[MAX_TIT+1];
    char tip[MAX_TIP+1];
    char aut[MAX_AUT+1];
    int ano;
    int val;
    char img[MAX_IMG];
    int NRR;
  };

  struct registro *mataux; /* Vetor auxiliar de estruturas */

  ordenaindice(pk); /* Reoordena o pk de chaves */

  arq = fopen(LISTAHTML, "w");
 
  mataux = malloc(pk->listasktam * sizeof(struct registro));

  fprintf(arq, "<html><head><title>Banco de Dados de Obras de Arte</title></head><body>");
  fprintf(arq, "<br><p align='center'><font color=green size=5>******* Listagem Completa do Banco de Dados *******</font></p><br>");

  j = pk->listasktam;
  for(x=0; x < pk->listasktam;x++){
    if ( (strcmp(pk->listask[x].pk, "*") ) == 0) j--;
  }

  fprintf(arq, "<br><br><hr><i>Numero de Obras Registradas: %d</i><br><hr><br><br><br>", j);

  i=x=0;
  while(i<pk->listasktam){
    
    /* Percorre as listask (linhas) do pk */
    for (i=x; i<pk->listasktam; i++) {
      
      /* Posiciona o cursor do arquivo base no comeco do registro a ser impresso */
      pos = (pk->listask[i].pos) * REGTAM;
      
      
      /* Percorre os caracteres da chave - Titulo --------------------*/
      fseek(*basept,pos*sizeof(char),SEEK_SET);
      for(j=pos, auxind=0; j < (pos + MAX_TIT); j++, auxind++) {
	let = getc(*basept); /* Le o caractere do arquivo*/
	mataux[i].tit[auxind] = let; /* Grava o caractere no vetor auxiliar */
	
	/* Termina a leitura quando encontra 2 espacos */
	if (let == ' ') spc++;
	if (let != ' ') spc = 0;
	if (spc == 2) {
	  mataux[i].tit[auxind-1] = '\0';
	  break;
	}
      }
      if ( (strcmp(mataux[i].tit, "*") ) == 0){
	x++;
	break;
      }
      fprintf(arq, "<b>Titulo:</b> ");
      fprintf(arq, "%s", mataux[i].tit);
      fprintf(arq, "<br>");
      
      /* Percorre os caracteres da chave - Tipo ----------------------*/
      fseek(*basept,(pos*sizeof(char))+MAX_TIT, SEEK_SET); /* Posiciona o cursor corretamente */
      for(j = pos + MAX_TIT, auxind=0; j < (pos + MAX_TIT + MAX_TIP); j++, auxind++) {
	let = getc(*basept); /* Le o caractere do arquivo*/
	mataux[i].tip[auxind] = let; /* Grava o caractere no vetor auxiliar */
	
	/* Termina a leitura quando encontra 2 espacos */
	if (let == ' ') spc++;
      if (let != ' ') spc = 0;
      if (spc == 2) {
	mataux[i].tip[auxind-1] = '\0';
	break;
      }
      }
      fprintf(arq, "<b>Tipo:</b> ");
      fprintf(arq, "%s", mataux[i].tip);
      fprintf(arq, "<br>");
      
      /* Percorre os caracteres da chave - Autor ---------------------*/
      fseek(*basept,(pos*sizeof(char))+MAX_TIT+MAX_TIP, SEEK_SET); /* Posiciona o cursor corretamente */
      for(j = pos + MAX_TIT + MAX_TIP, auxind=0; j < (pos + MAX_TIT + MAX_TIP + MAX_AUT); j++, auxind++) {
	let = getc(*basept); /* Le o caractere do arquivo*/
	mataux[i].aut[auxind] = let; /* Grava o caractere no vetor auxiliar */
	
     
	/* Termina a leitura quando encontra 2 espacos */
	if (let == ' ') spc++;
	if (let != ' ') spc = 0;
	
	if (spc == 2) {
	  mataux[i].aut[auxind-1] = '\0';
	  break;
	}
      }

      fprintf(arq, "<b>Autor:</b> ");
      fprintf(arq, "%s", mataux[i].aut);
      fprintf(arq, "<br>");
      
      /* Le o inteiro - Ano -------------------------------------------*/
      fseek(*basept,(pos*sizeof(char))+MAX_TIT+MAX_TIP+MAX_AUT, SEEK_SET); /* Posiciona o cursor corretamente */
      fscanf(*basept,"%04d",&mataux[i].ano);
      fprintf(arq, "<b>Ano:</b> ");
      fprintf(arq, "%d", mataux[i].ano);
      fprintf(arq, "<br>"); 
      
      /* Le o inteiro - Valor ----------------------------------------*/
      fseek(*basept,(pos*sizeof(char))+MAX_TIT+MAX_TIP+MAX_AUT+MAX_ANO, SEEK_SET); /* Posiciona o cursor corretamente */
      fscanf(*basept,"%012d",&mataux[i].val);
      fprintf(arq, "<b>Valor:</b> ");
      fprintf(arq, "R$ %d,00", mataux[i].val);
      fprintf(arq, "<br>");
      
      
      /* Percorre os caracteres da chave - Imagem ---------------------*/
      fseek(*basept,(pos*sizeof(char))+MAX_TIT+MAX_TIP+MAX_AUT+MAX_ANO+MAX_VAL, SEEK_SET); /* Posiciona o cursor corretamente */
      for(j = pos + MAX_TIT + MAX_TIP + MAX_AUT + MAX_ANO + MAX_VAL, auxind=0; j < (pos + MAX_TIT + MAX_TIP + MAX_AUT + MAX_ANO + MAX_VAL + MAX_IMG); j++, auxind++) {
	let = getc(*basept); /* Le o caractere do arquivo*/
	mataux[i].img[auxind] = let; /* Grava o caractere no vetor auxiliar */
      }
      fprintf(arq, "<br>");
      fprintf(arq, "<img src=img/");
      for(cimg=0; cimg<(MAX_IMG - IMG_EXT); cimg++) putc(mataux[i].img[cimg],arq);
      fprintf(arq, ".");
      for(cimg=0; cimg<(IMG_EXT); cimg++) putc(mataux[i].img[cimg+(MAX_IMG - IMG_EXT)],arq);
      fprintf(arq, ">");
      fprintf(arq,"<br><hr><br>");
    }
  }
  fprintf(arq,"<br><br><p align='center'>********** FIM DA LISTA **********</p>");
  fprintf(arq, "</body></html>");
  fclose(arq);
  free(mataux);
}


/* ------------------------------------------------------------------------------- */

/* Funcao auxiliar de comparacao utilizada na bsearch */
int aux_bsearch(const void* key, const void* elem) {
  return(strcmp((char*)key,((tipocelsk*)elem)->sk));
}


/* ------------------------------------------------------------------------------- */

void menubusca(FILE **basept, FILE **arq, reg *dados, tipoindice *pk, tipoindice *titulo, tipoindice *tipo, tipoindice *autor, tipoindice *ano, int *alocados) {

  int cont=0,NRR=0, posicao=-1;
  char opt, target[MAX_TIT+1];
  tipocelsk *f;
  FILE *html = NULL; /* Arquivo das impressoes HTML */

  system("clear");

  printf("\n\n ***********  M E N U     de     B U S C A  *********** \n");
  printf("|                                                      |\n");
  printf("|   1 - BUSCA por  [C]have Primaria                    |\n");
  printf("|   2 - BUSCA pelo [T]ITULO                            |\n");
  printf("|   3 - BUSCA pelo T[I]PO                              |\n");
  printf("|   4 - BUSCA pelo [A]UTOR                             |\n");
  printf("|   5 - BUSCA pelo A[N]O                               |\n");
  printf("|   6 - [V]oltar para MENU PRINCIPAL                   |\n");
  printf("|                                                      |\n");
  printf(" ****************************************************** \n");
  printf("\n ==> Digite o numero ou a letra da opcao desejada: ");

  opt = getchar();
  
  /* Age de acordo com a opcao do usuario */
  switch(opt) {

  case '1':
  case 'c':
  case 'C':

    /*-------------------------------------TITULO PK--------------------------------------------*/
    system("clear");    
    getchar();
    printf("\n ==> Busca [Titulo PK]: ");
    scanf("%[^\n]", target);
    posicao = strlen(target);

    for(cont=posicao; cont < MAX_TIT; cont++){
      target[cont] = ' ';
    }
    target[cont] = '\0';

    f = buscat(pk, target);

    /* Abrindo o Arquivo e Imprimindo Headers HTML */
    html = fopen(BUSCAHTML, "w");
    fprintf(html, "<html><head><title>Resultado da Busca: %s</title></head><body>",target);
    fprintf(html, "<br><p align='center'><font color=green size=5>*** Resultado da Busca por Chave Primaria ***</font></p><br><hr><br>");
    fprintf(html, "<p align='center'><font color=blue size=4>Campo Utilizado: TITULO [PK]<br><br>Palavra Procurada: <b>%s</b></font></p><br><hr><br><br>",target);

    if(f != NULL){
      imprimeBusca(basept, html, f->pos);
      f = NULL;
    }
    
    /* Fechando o Arquivo e Imprimindo Headers HTML */
    fprintf(html,"<br><br><hr><br><br>");
    fprintf(html, "</body></html>");
    fclose(html);


    if(f == NULL) {
      printf("\n ***** Resultado impresso no arquivo %s !! ***** \n\n",BUSCAHTML);
      printf(" Pressione <enter> para retornar ao menu.....");
      getchar();
      getchar();
      system("clear");
      menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu de Busca */
      return;
    }
    
    system("clear");
    menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados); /* Volta para o menu de Busca */
    break;

    /*-------------------------------------TITULO QUEBRADO--------------------------------------*/
    
  case '2':
  case 't':
  case 'T':

    system("clear");
    getchar();
    printf("\n ==> Busca [Titulo]: ");
    scanf("%[^\n]", target);

    *arq = fopen(TITPK, "r");

    f = buscat(titulo, target);

    /* Abrindo o Arquivo e Imprimindo Headers HTML */
    html = fopen(BUSCAHTML, "w");
    fprintf(html, "<html><head><title>Resultado da Busca: %s</title></head><body>",target);
    fprintf(html, "<br><p align='center'><font color=green size=5>*** Resultado da Busca por Chave Secundaria ***</font></p><br><hr><br>");
    fprintf(html, "<p align='center'><font color=blue size=4>Campo Utilizado: TITULO<br><br>Palavra Procurada: <b>%s</b></font></p><br><hr><br><br>",target);

    if(f != NULL){
      
      posicao = f->pos*(MAX_TIT + TAMPOSREL);
      while(1){
	fseek(*arq, posicao*sizeof(char), SEEK_SET); /* Posiciona o ponteiro no arquivo de PKs relacionadas */
	fscanf(*arq, "%04d", &posicao); /* Le qual sera a prox posicao */
	fscanf(*arq, "%200[^\n]", target);

	for(cont=0;cont < pk->listasktam; cont++){ /* Acha a msm PK na RAM dos INDICES Primarios  */
	  if( strcmp(target, pk->listask[cont].sk) == 0) break;
	}

	NRR = pk->listask[cont].pos; /* Pega o NRR da mesma  */
	imprimeBusca(basept, html, NRR); /* Imprime no arquivo HTML  */
	fprintf(html, "<br><hr><br>");
	if(posicao == -1) break;
	posicao = posicao*(MAX_TIT + TAMPOSREL); /* Atualiza o ponteiro do arquivo  */
      }
      f = NULL;
    }
    
    /* Fechando o Arquivo e Imprimindo Headers HTML */
    fprintf(html,"<br><br><hr><br><br>");
    fprintf(html, "</body></html>");
    fclose(html);


    if(f == NULL) {
      printf("\n ***** Resultado impresso no arquivo %s !! ***** \n\n",BUSCAHTML);
      printf(" Pressione <enter> para retornar ao menu.....");
      getchar();
      getchar();
      system("clear");
      fclose(*arq);
      menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu de Busca */
      return;
    }
    
    system("clear");
    menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados); /* Volta para o menu de Busca */
    break;
    
    /*-------------------------------------TIPO-------------------------------------------------*/

  case '3':
  case 'i':
  case 'I':
    /* Busca pelo TIPO */
    system("clear");
    getchar();
    printf("\n ==> Busca [Tipo]: ");
    scanf("%[^\n]", target);

    *arq = fopen(TIPPK, "r");

    f = buscat(tipo, target);

    /* Abrindo o Arquivo e Imprimindo Headers HTML */
    html = fopen(BUSCAHTML, "w");
    fprintf(html, "<html><head><title>Resultado da Busca: %s</title></head><body>",target);
    fprintf(html, "<br><p align='center'><font color=green size=5>*** Resultado da Busca por Chave Secundaria ***</font></p><br><hr><br>");
    fprintf(html, "<p align='center'><font color=blue size=4>Campo Utilizado: TIPO<br><br>Palavra Procurada: <b>%s</b></font></p><br><hr><br><br>",target);

    if(f != NULL){
      
      posicao = f->pos*(MAX_TIT + TAMPOSREL);
      while(1){
	fseek(*arq, posicao*sizeof(char), SEEK_SET); /* Posiciona o ponteiro no arquivo de PKs relacionadas */
	fscanf(*arq, "%04d", &posicao); /* Le qual sera a prox posicao */
	fscanf(*arq, "%200[^\n]", target);

	for(cont=0;cont < pk->listasktam; cont++){ /* Acha a msm PK na RAM dos INDICES Primarios  */
	  if( strcmp(target, pk->listask[cont].sk) == 0) break;
	}

	NRR = pk->listask[cont].pos; /* Pega o NRR da mesma  */
	imprimeBusca(basept, html, NRR); /* Imprime no arquivo HTML  */
	fprintf(html, "<br><hr><br>");
	if(posicao == -1) break;
	posicao = posicao*(MAX_TIT + TAMPOSREL); /* Atualiza o ponteiro do arquivo  */
      }
      f = NULL;
    }

    /* Fechando o Arquivo e Imprimindo Headers HTML */
    fprintf(html,"<br><br><hr><br><br>");
    fprintf(html, "</body></html>");
    fclose(html);    


    if(f == NULL) {
      printf("\n ***** Resultado impresso no arquivo %s !! ***** \n\n",BUSCAHTML);
      printf(" Pressione <enter> para retornar ao menu.....");
      getchar();
      getchar();
      system("clear");
      fclose(*arq);
      menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu de Busca */
      return;
    }
    
    system("clear");
    menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu de Busca */
    break;
    
    /*-------------------------------------AUTOR------------------------------------------------*/
    
    
  case '4':
  case 'a':
  case 'A':
    /* Busca pelo AUTOR */
    system("clear");
    getchar();
    printf("\n ==> Busca [Autor]: ");
    scanf("%[^\n]", target);

    *arq = fopen(AUTPK, "r");

    f = buscat(autor, target);
    
    /* Abrindo o Arquivo e Imprimindo Headers HTML */
    html = fopen(BUSCAHTML, "w");
    fprintf(html, "<html><head><title>Resultado da Busca: %s</title></head><body>",target);
    fprintf(html, "<br><p align='center'><font color=green size=5>*** Resultado da Busca por Chave Secundaria ***</font></p><br><hr><br>");
    fprintf(html, "<p align='center'><font color=blue size=4>Campo Utilizado: AUTOR<br><br>Palavra Procurada: <b>%s</b></font></p><br><hr><br><br>",target);

    if(f != NULL){
      
      posicao = f->pos*(MAX_TIT + TAMPOSREL);
      while(1){
	fseek(*arq, posicao*sizeof(char), SEEK_SET); /* Posiciona o ponteiro no arquivo de PKs relacionadas */
	fscanf(*arq, "%04d", &posicao); /* Le qual sera a prox posicao */
	fscanf(*arq, "%200[^\n]", target);

	for(cont=0;cont < pk->listasktam; cont++){ /* Acha a msm PK na RAM dos INDICES Primarios  */
	  if( strcmp(target, pk->listask[cont].sk) == 0) break;
	}

	NRR = pk->listask[cont].pos; /* Pega o NRR da mesma  */
	imprimeBusca(basept, html, NRR); /* Imprime no arquivo HTML  */
	fprintf(html, "<br><hr><br>");
	if(posicao == -1) break;
	posicao = posicao*(MAX_TIT + TAMPOSREL); /* Atualiza o ponteiro do arquivo  */
      }
      f = NULL;
    }
    
    /* Fechando o Arquivo e Imprimindo Headers HTML */
    fprintf(html,"<br><br><hr><br><br>");
    fprintf(html, "</body></html>");
    fclose(html);  
 
   
    if(f == NULL) {
      printf("\n ***** Resultado impresso no arquivo %s !! ***** \n\n",BUSCAHTML);
      printf(" Pressione <enter> para retornar ao menu.....");
      getchar();
      getchar();
      system("clear");
      fclose(*arq);
      menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu de Busca */
      return;
    }
    
    system("clear");
    menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu de Busca */

    break;

    /*-----------------------------ANO----------------------------------------------------------*/

  case '5':
  case 'n':
  case 'N':
    /* Busca pelo ANO */
    system("clear");
    getchar();
    printf("\n ==> Busca [Ano]: ");
    scanf("%[^\n]", target);

    *arq = fopen(ANOPK, "r");

    f = buscat(ano, target);
    
    /* Abrindo o Arquivo e Imprimindo Headers HTML */
    html = fopen(BUSCAHTML, "w");
    fprintf(html, "<html><head><title>Resultado da Busca: %s</title></head><body>",target);
    fprintf(html, "<br><p align='center'><font color=green size=5>*** Resultado da Busca por Chave Secundaria ***</font></p><br><hr><br>");
    fprintf(html, "<p align='center'><font color=blue size=4>Campo Utilizado: ANO<br><br>Entrada Procurada: <b>%s</b></font></p><br><hr><br><br>",target);

    if(f != NULL){
      
      posicao = f->pos*(MAX_TIT + TAMPOSREL);
      while(1){
	fseek(*arq, posicao*sizeof(char), SEEK_SET); /* Posiciona o ponteiro no arquivo de PKs relacionadas */
	fscanf(*arq, "%04d", &posicao); /* Le qual sera a prox posicao */
	fscanf(*arq, "%200[^\n]", target);

	for(cont=0;cont < pk->listasktam; cont++){ /* Acha a msm PK na RAM dos INDICES Primarios  */
	  if( strcmp(target, pk->listask[cont].sk) == 0) break;
	}

	NRR = pk->listask[cont].pos; /* Pega o NRR da mesma  */
	imprimeBusca(basept, html, NRR); /* Imprime no arquivo HTML  */
	fprintf(html, "<br><hr><br>");
	if(posicao == -1) break;
	posicao = posicao*(MAX_TIT + TAMPOSREL); /* Atualiza o ponteiro do arquivo  */
      }
      f = NULL;
    }

    /* Fechando o Arquivo e Imprimindo Headers HTML */
    fprintf(html,"<br><br><hr><br><br>");
    fprintf(html, "</body></html>");
    fclose(html);  

    
    if(f == NULL) {
      printf("\n ***** Resultado impresso no arquivo %s !! ***** \n\n",BUSCAHTML);
      printf(" Pressione <enter> para retornar ao menu.....");
      getchar();
      getchar();
      system("clear");
      fclose(*arq);
      menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu de Busca */
      return;
    }
    
    system("clear");
    menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);  /* Volta para o menu de Busca */
    
    break;
    
    /*--------------------------------------------------------------------------------------------------*/
    
  case '6':
  case 'v':
  case 'V':
    system("clear");
    getchar();
    menup(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados);/* Volta para o menu principal */
    break;
    
  default:
    /* Em entrada invalida, fecha o programa */
    printf("\n\n Opcao INVALIDA!\n Pressione <enter> para retornar ao menu de BUSCA...");
    getchar(); /* Aguarda o usuario digitar enter, para a visualizacao da mensagem */
    system("clear");
    menubusca(basept, arq, dados, pk, titulo, tipo, autor, ano, alocados); /* Volta para o menu de Busca */
    break;
  }
}

/* ------------------------------------------------------------------------------- */

/* Imprime o resultado da busca por chave secundaria em um arquivo HTML */
void imprimeBusca(FILE **basept, FILE *arq, int NRR) {
  
  int pos, cimg=0;
  int j, auxind=0, spc=0;
  char let;
  
  struct registro {
    char tit[MAX_TIT+1];
    char tip[MAX_TIP+1];
    char aut[MAX_AUT+1];
    int ano;
    int val;
    char img[MAX_IMG];
    int NRR;
  };
  
  struct registro mataux; /* Vetor auxiliar de estruturas */
  
  /* Posiciona o cursor do arquivo base no comeco do registro a ser impresso */
  pos = NRR * REGTAM;
  
  /* Percorre os caracteres da chave - Titulo --------------------*/
  fseek(*basept,pos*sizeof(char),SEEK_SET);
  for(j=pos, auxind=0; j < (pos + MAX_TIT); j++, auxind++) {
    let = getc(*basept); /* Le o caractere do arquivo*/
    mataux.tit[auxind] = let; /* Grava o caractere no vetor auxiliar */
    
    /* Termina a leitura quando encontra 2 espacos */
    if (let == ' ') spc++;
    if (let != ' ') spc = 0;
    if (spc == 2) {
      mataux.tit[auxind-1] = '\0';
      break;
    }
  }
  fprintf(arq, "<b>Titulo:</b> ");
  fprintf(arq, "%s", mataux.tit);
  fprintf(arq, "<br>");
  
  /* Percorre os caracteres da chave - Tipo ----------------------*/
  fseek(*basept,(pos*sizeof(char))+MAX_TIT, SEEK_SET); /* Posiciona o cursor corretamente */
  for(j = pos + MAX_TIT, auxind=0; j < (pos + MAX_TIT + MAX_TIP); j++, auxind++) {
    let = getc(*basept); /* Le o caractere do arquivo*/
    mataux.tip[auxind] = let; /* Grava o caractere no vetor auxiliar */
    
    /* Termina a leitura quando encontra 2 espacos */
    if (let == ' ') spc++;
    if (let != ' ') spc = 0;
    if (spc == 2) {
      mataux.tip[auxind-1] = '\0';
      break;
    }
  }
  fprintf(arq, "<b>Tipo:</b> ");
  fprintf(arq, "%s", mataux.tip);
  fprintf(arq, "<br>");
  
  /* Percorre os caracteres da chave - Autor ---------------------*/
  fseek(*basept,(pos*sizeof(char))+MAX_TIT+MAX_TIP, SEEK_SET); /* Posiciona o cursor corretamente */
  for(j = pos + MAX_TIT + MAX_TIP, auxind=0; j < (pos + MAX_TIT + MAX_TIP + MAX_AUT); j++, auxind++) {
    let = getc(*basept); /* Le o caractere do arquivo*/
    mataux.aut[auxind] = let; /* Grava o caractere no vetor auxiliar */
    
    
    /* Termina a leitura quando encontra 2 espacos */
    if (let == ' ') spc++;
    if (let != ' ') spc = 0;
    
    if (spc == 2) {
      mataux.aut[auxind-1] = '\0';
      break;
    }
  }
  
  fprintf(arq, "<b>Autor:</b> ");
  fprintf(arq, "%s", mataux.aut);
  fprintf(arq, "<br>");
  
  /* Le o inteiro - Ano -------------------------------------------*/
  fseek(*basept,(pos*sizeof(char))+MAX_TIT+MAX_TIP+MAX_AUT, SEEK_SET); /* Posiciona o cursor corretamente */
  fscanf(*basept,"%04d",&mataux.ano);
  fprintf(arq, "<b>Ano:</b> ");
  fprintf(arq, "%d", mataux.ano);
  fprintf(arq, "<br>"); 
  
  /* Le o inteiro - Valor ----------------------------------------*/
  fseek(*basept,(pos*sizeof(char))+MAX_TIT+MAX_TIP+MAX_AUT+MAX_ANO, SEEK_SET); /* Posiciona o cursor corretamente */
  fscanf(*basept,"%012d",&mataux.val);
  fprintf(arq, "<b>Valor:</b> ");
  fprintf(arq, "R$ %d,00", mataux.val);
  fprintf(arq, "<br>");
  
  /* Percorre os caracteres da chave - Imagem ---------------------*/
  fseek(*basept,(pos*sizeof(char))+MAX_TIT+MAX_TIP+MAX_AUT+MAX_ANO+MAX_VAL, SEEK_SET); /* Posiciona o cursor corretamente */
  for(j = pos + MAX_TIT + MAX_TIP + MAX_AUT + MAX_ANO + MAX_VAL, auxind=0; j < (pos + MAX_TIT + MAX_TIP + MAX_AUT + MAX_ANO + MAX_VAL + MAX_IMG); j++, auxind++) {
    let = getc(*basept); /* Le o caractere do arquivo*/
    mataux.img[auxind] = let; /* Grava o caractere no vetor auxiliar */
  }
  fprintf(arq, "<br>");
  fprintf(arq, "<img src=img/");
  for(cimg=0; cimg<(MAX_IMG - IMG_EXT); cimg++) putc(mataux.img[cimg],arq);
  fprintf(arq, ".");
  for(cimg=0; cimg<IMG_EXT; cimg++) putc(mataux.img[cimg+(MAX_IMG - IMG_EXT)],arq);
  fprintf(arq, ">");
}

/* ------------------------------------------------------------------------------- */
